Problem

Two related thread-safety bugs make it unsafe to cache and reuse parsed Jsonata instances:

Issue #93 — Bindings leak across instances on the same thread

The constructor sets current.set(this) on a single static ThreadLocal<Jsonata>. When a second instance is constructed on the same thread, it overwrites the first. Subsequent evaluations of the first instance can silently use the second instance's per-thread evaluator state, causing environment bindings to leak across unrelated expressions.

Issue #90 — $eval() returns null for nested/deep contexts

_evaluate() stores evaluation state such as input and environment as mutable instance fields during recursive evaluation. When $eval() reads that state through Jsonata.current.get(), it can observe whatever the most recent recursive _evaluate() call wrote, rather than the correct calling context for that $eval() invocation. This causes cases like $eval($.funcs.func) to return null instead of the expected result.

Both bugs stem from the same root cause: per-evaluation mutable state stored on the shared Jsonata instance and accessed through a single static ThreadLocal<Jsonata>.

Solution (minimal fix)

Preserve the context during evaluate on the stack.
Thus we can keep the original code structure and minimize the # of changed lines of code

Original Solution (not merged - used minimal fix)

Extract all per-evaluation mutable state into a lightweight EvalContext value object stored in a single static ThreadLocal<EvalContext>.

This separates:

• the parsed expression and base configuration on Jsonata
• the live execution state for the current evaluation

As a result, Jsonata no longer stores per-evaluation mutable state, and parsed expressions can be safely cached and reused across threads after setup.

What changed

Jsonata.java

Functions.java

• All Jsonata.current.get() call sites now read from Jsonata.evalContext.get()
• $eval(), $now(), $millis(), and lambda application now use EvalContext
• funcApply() no longer performs redundant repeated ThreadLocal.get() calls

Design

Before:
  Jsonata instance held mutable evaluation state
  static ThreadLocal<Jsonata>
  per-thread cloning

After:
  Jsonata holds parsed expression + base configuration
  static ThreadLocal<EvalContext>
  no cloning